package com.baoyouqun.domain.VO;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.baoyouqun.domain.Enum.SystemConfigType;
import com.baoyouqun.entity.SystemConfig;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serial;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Data
public class PostTypeDTO implements Serializable {
    @Serial
    private static final long serialVersionUID = 1L;
    private String id;

    @ApiModelProperty(value = "一级子分类列表，无有效元素时返回[]")
    private List<PostTypeSonDTO> list = new ArrayList<>();

    /**
     * 从SystemConfig转换（全量过滤空对象）
     */
    public static PostTypeDTO fromSystemConfig(SystemConfig systemConfig) {
        if (systemConfig == null || !SystemConfigType.POST_TYPE.equals(systemConfig.getConfigType())) {
            throw new IllegalArgumentException("无效的帖子分类配置数据");
        }

        PostTypeDTO dto = new PostTypeDTO();
        dto.setId(systemConfig.getId());

        String subCategoryJson = systemConfig.getInfo8();
        if (subCategoryJson != null && !subCategoryJson.trim().isEmpty()) {
            try {
                List<PostTypeSonDTO> parsedList = JSON.parseObject(
                        subCategoryJson,
                        new TypeReference<List<PostTypeSonDTO>>() {
                        }
                );
                dto.setList(parsedList); // 通过setList自动过滤
            } catch (Exception e) {
                throw new RuntimeException("反序列化失败: " + subCategoryJson, e);
            }
        }

        return dto;
    }

    /**
     * 设置列表时自动过滤所有空对象（包括子列表）
     */
    public void setList(List<PostTypeSonDTO> list) {
        if (list == null) {
            this.list = new ArrayList<>();
        } else {
            // 过滤一级列表中的空对象，并递归清理子列表
            this.list = list.stream()
                    .filter(Objects::nonNull)
                    .filter(son -> !son.isEmpty()) // 过滤一级空对象
                    .peek(son -> son.cleanEmptyChildren()) // 清理子列表中的空对象
                    .collect(Collectors.toList());
        }
    }

    /**
     * 转换为SystemConfig（确保存储的JSON无空对象）
     */
    public SystemConfig toSystemConfig(SystemConfig config) {
        if (config == null) {
            throw new IllegalArgumentException("SystemConfig参数不能为空");
        }

        config.setConfigType(SystemConfigType.POST_TYPE);
        config.setConfigName(SystemConfigType.POST_TYPE.getDesc());

        try {
            // 再次过滤确保万无一失，然后序列化
            List<PostTypeSonDTO> cleanList = this.list.stream()
                    .filter(son -> !son.isEmpty())
                    .peek(son -> son.cleanEmptyChildren())
                    .collect(Collectors.toList());
            config.setInfo8(JSON.toJSONString(cleanList));
        } catch (Exception e) {
            throw new RuntimeException("序列化失败", e);
        }

        return config;
    }

    @Data
    public static class PostTypeSonDTO implements Serializable {
        private static final long serialVersionUID = 1L;

        @ApiModelProperty(value = "分类标题")
        private String title;

        @ApiModelProperty(value = "数量")
        private Integer count;

        @ApiModelProperty(value = "子列表")
        private List<PostTypeSonDTO> list = new ArrayList<>();

        // 注意：如果JSON中出现empty字段，可能是lombok的@Data或其他逻辑自动生成的，需检查来源
        // 若无需此字段，可通过@JsonIgnore排除序列化

        /**
         * 判断当前是否为空对象（所有核心属性为空）
         */
        public boolean isEmpty() {
            // 核心判断：title和count都为空，且子列表无有效元素
            boolean coreEmpty = (title == null || title.trim().isEmpty())
                    && (count == null);
            // 子列表为空或只有空对象，也视为当前对象无意义
            boolean childrenEmpty = list.stream()
                    .allMatch(son -> son == null || son.isEmpty());
            return coreEmpty && childrenEmpty;
        }

        /**
         * 递归清理子列表中的空对象
         */
        public void cleanEmptyChildren() {
            if (this.list == null) {
                this.list = new ArrayList<>();
                return;
            }
            // 过滤子列表空对象，并递归清理孙子列表
            List<PostTypeSonDTO> cleaned = this.list.stream()
                    .filter(Objects::nonNull)
                    .filter(son -> !son.isEmpty())
                    .peek(son -> son.cleanEmptyChildren()) // 递归处理
                    .collect(Collectors.toList());
            this.list = cleaned;
        }
    }
}
